var ALog=(new function s() {
	//最大文件数
	var mMaxFile = 3;
	//文件最大size
	var mMaxFileSize = 1 * 1024 * 1024;
	//文件名
	var mFileName = 'apicloud_log';
	//文件目录
	var mDicPath = 'fs://alog';
	var mDefaultOption = {

	};
	//apicloud文件模块
	var fs;
	/**
	 * 初始化日志模块
	 * @param {Object} option - 设置参数
	 */
	function init(option) {
		fs = api.require('fs');
	}

	/**
	 * 级别为i的信息的写入api
	 * 写入的内容。
	 */
	function i(logContent) {
		init();
		writeLog(logContent);
	}

	/**
	 * 写入日志
	 * @param {String} logContent - 日志内容
	 */
	function writeLog(logContent) {
		if (fs == null) {
			throw new Error('未初始化！');
			return;
		}
		if (logContent == null) {
			return;
		}
		//首个日志文件名
		var fileName = mFileName + '_1.txt';
		var filePath = mDicPath + '/' + fileName;
		//文件是否存在，默认为fasle;
		var isHasFile = false;
		//文件是否超出大小限制
		var overDatas = false;
		//是否为最后一个文件
		var isFinallyFile = false;
		//判断目录是否存在，不存在就创建目录，反之，进入下一步，判断日志文件的存在。
		var isHasDic = hasFiles(mDicPath);
		if (isHasDic) {
			//判断日志文件的存在。
			isHasFile = judgeLogFileExist();
			if (isHasFile) {
				//存在文件，获取最新修改的文件的文件路径。
				var nestData=getNewestUpdateFile();
				if(nestData==null){
					return;
				}
				var nestIndex=nestData.index;
				filePath=nestData.newestFilePath;
				//判断文件是否超出限制
				overDatas = judgeLogFileSize(filePath);
				if (overDatas.is == 1) {
					//超出限制，判断是否为最后一个文件
					isFinallyFile = judgeLogFileFinally(filePath);
					if (isFinallyFile) {
						//是，覆盖第一个文件，写日志。
						fileName = mFileName + '_' + (1) + '.txt';
						filePath = mDicPath + '/' + fileName;
						writeLogToFile(filePath, logContent, true, 0);
					} else {
						//否，判断下一个文件是否存在
						fileName=createFileName(nestIndex+1);
						filePath = mDicPath + '/' + fileName;
						if(hasFiles(filePath)){
							//是，覆盖下一个文件;
							writeLogToFile(filePath, logContent, true, 0);
						}else{
							//否，创建下一个文件;
							createLogFileResult(filePath, logContent);
						}
					}
				} else if(overDatas.is == 0){
					//未超出限制，写入日志
					writeLogToFile(filePath, logContent, false, overDatas.size);
				}else{
					return;
				}
			} else {
				//不存在文件，新建文件。
				createLogFileResult(filePath, logContent);
			}
		} else {
			if (createDic(mDicPath)) {
				//创建首个日志文件
				createLogFileResult(filePath, logContent);
			} else {
				return;
			}
		}
	}

	/**
	 * 判断日志文件是否为最后一个文件
	 * @return 返回值；true,是最后一个文件，反之，不是。
	 */
	function judgeLogFileFinally(filePath) {
		var fileName=filePath.split(mDicPath+'/')[1];
		var index = fileName.indexOf('.txt');
		var num = fileName.charAt(index - 1);
		if (num == mMaxFile) {
			return true;
		} else {
			return false;
		}
	}
	/**
	 * 获取最新修改的文件的路径 
	 */
	function getNewestUpdateFile(){
		var i = 1;
		var j;
		//文件路径
		var filePath = mDicPath + '/';
		//文件名
		var fileName = mFileName;
		//
		var newest=i;
		var newestFileName;
		var newestFilePath;
		var ret1;
		var ret2;
		var dateUpdate1;
		var dateUpdate2;
		//循环判断文件是否存在,从最大文件名开始判断
		for (; i <= mMaxFile; ) {
			//设置最新修改的文件为第一个文件
			newestFileName=createFileName(newest);
			newestFilePath=mDicPath + '/'+newestFileName;
			fileName = createFileName(i+=1);
			filePath=mDicPath + '/'+fileName;
			//判断最新修改的文件是否存在，存在，进入下一步，不存在，返回空
			if(hasFiles(newestFilePath)){
				//判断后一个文件是否存在,存在，进入下一步，不存在，返回当前最新修改文件
				if(hasFiles(filePath)){
					//比较最新修改文件和后一个文件的时间戳大小
					ret1=judgeLogFileSize(newestFilePath);
					dateUpdate1=ret1.date;
					ret2=judgeLogFileSize(filePath);
					dateUpdate2=ret2.date;
					//取到最大时间戳的index;
					if(dateUpdate1<=dateUpdate2){
						newest=i;
					}else{
						continue;
					}
				}else{
					break;
				}
			}else{
				return null;
			}
		}
		newestFileName=createFileName(newest);
		newestFilePath=mDicPath + '/'+newestFileName;
		
		var reD={};
		reD.newestFilePath=newestFilePath;
		reD.index=newest;
		return reD;
	}

	/**
	 * 创建文件结果处理
	 * @param {boolean} result - 创建文件的结果
	 */
	function createLogFileResult(filePath, logContent) {
		if (createFile(filePath)) {
			//创建成功，开始写入。
			writeLogToFile(filePath, logContent, true, 0);
		} else {
			//创建失败，提示有错误。
			return;
		}
	}

	/**
	 * 判断日志文件是否存在
	 * 
	 */
	function judgeLogFileExist() {
		var i = 1;
		//文件路径
		var filePath = mDicPath + '/';
		//文件名
		var fileName = mFileName;
		//是否文件存在;
		var isHasFile = false;
		//循环判断文件是否存在,从最大文件名开始判断
		for (; i <= mMaxFile; i++) {
			fileName = createFileName(i);
			if (hasFiles(filePath + fileName)) {
				isHasFile=true;
				break;
			}
		}
		return isHasFile;
	}
	
	function createFileName(i){
		return mFileName + '_' + i + '.txt';
	}
	
	

	/**
	 * 判断日志文件的大小是否超出最大限制
	 * @param {String} filePath - 文件路径
	 * @return {Object} is==-1,操作文件失败;is==0,文件未超限制;is==1,文件超限制;
	 */
	function judgeLogFileSize(filePath) {
		var ret = fs.getAttributeSync({
			path : filePath
		});
		var re={};
		if (ret.status) {
			var attr = ret.attribute;
			var se = attr.size;
			if (se >= mMaxFileSize) {
				re.is=1;
			} else {
				re.is=0;
			}
			re.size=se;
			re.date=attr.modificationDate;
		} else {
			re.is=-1;
		}
		return re;
	}

	/**
	 * 将日志写入文件。
	 * @param {String} filePath - 日志文件路径
	 * @param {String} logContent - 日志内容
	 * @param {boolean} overwrite - 是否覆盖原内容，默认不覆盖
	 * @param {Number} startLen - 开始位置
	 */
	function writeLogToFile(filePath, logContent, overwrite, startLen) {
		var start;
		var strategy;
		var content=getCurrentDate()+'   '+api.winName+'     '+ logContent + '\n';
		start = startLen || 0;
		if (overwrite) {
			//覆盖起始位置后所有
			strategy = -1;
		} else {
			//不覆盖，插入
			strategy = 0;
		}
		var ret = fs.writeByLengthSync({
			path : filePath,
			content :content,
			place : {
				start : start,
				strategy : strategy
			}
		});
	}
	
	function getCurrentDate(){
		var dt='';
		var date=new Date();
		dt+=date.getFullYear();
		dt+=':';
		dt+=(date.getMonth()+1);
		dt+=':';
		dt+=date.getDate();
		dt+=':';
		dt+=date.getHours();
		dt+=':';
		dt+=date.getMinutes();
		dt+=':';
		dt+=date.getSeconds();
		dt+=':';
		dt+=date.getMilliseconds();
		return dt;
	}

	/**
	 * 判断是否存在文件
	 * @param {String} path - 文件路径
	 * @return true,存在，反之，不存在
	 */
	function hasFiles(path) {
		var ret = fs.existSync({
			path : path
		});
		if (ret.exist) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 创建目录
	 * @param {String} path - 目录路径
	 * @return true==操作成功;反之,操作失败。
	 */
	function createDic(path) {
		var ret = fs.createDirSync({
			path : path
		});
		if (ret.status) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 创建文件
	 * @param {String} path - 文件路径
	 * @return true==操作成功;反之,操作失败。
	 */
	function createFile(path) {
		var ret = fs.createFileSync({
			path : path
		});
		if (ret.status) {
			return true;
		} else {
			return false;
		}
	}


	this.i = i;
}());
